﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using Recomendaciones.Entidades;
using System.Web.SessionState;
using System.Web.Security;

//Agregado 1-12. Se modifico todo.

/// <summary>
/// Summary description for servicio
/// </summary>
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[System.ComponentModel.ToolboxItem(false)]
// To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line. 
[System.Web.Script.Services.ScriptService]
public class servicio : System.Web.Services.WebService
{
    public servicio()
    {
        //Uncomment the following line if using designed components 
        //InitializeComponent(); 
    }

    #region Peliculas

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarComentarioPelicula(string Pelicula_id, string usuario_id, string comentario, string puntaje)
    {
        try
        {
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                string usuario = ((Usuario)HttpContext.Current.Session["usuarioID"]).Id.ToString();
                ComentarioPeliculaServices comentarioPeliculaServices = new ComentarioPeliculaServices();
                resultado = comentarioPeliculaServices.InsertarComentarioPelicula(Pelicula_id, usuario, comentario, puntaje);
            }
            else
            {
                resultado = "No log";
            }
            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ComentarioPeliculaDTO> ConsultarUltimosComentariosPelicula(string idPelicula)
    {
        try
        {
            int id = Convert.ToInt32(idPelicula);
            List<ComentarioPeliculaDTO> comentarioPeliculaDTO = new List<ComentarioPeliculaDTO>();
            ComentarioPeliculaServices comentarioPeliculaServices = new ComentarioPeliculaServices();
            List<ComentarioPelícula> comentarioPelicula = comentarioPeliculaServices.ObtenerUltimosComentarios(id);

            foreach (ComentarioPelícula comPeli in comentarioPelicula)
            {
                ComentarioPeliculaDTO dto = new ComentarioPeliculaDTO(comPeli);
                comentarioPeliculaDTO.Add(dto);
            }
            return comentarioPeliculaDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<PeliculaDTO> ConsultarTopTenPeliculas()
    {
        try
        {
            List<PeliculaDTO> peliculasDTO = new List<PeliculaDTO>();
            PeliculaServices peliculaServices = new PeliculaServices();
            List<Pelicula> peliculas = peliculaServices.ObtenerTopTen();

            foreach (Pelicula peli in peliculas)
            {
                PeliculaDTO dto = new PeliculaDTO(peli);
                peliculasDTO.Add(dto);
            }
            return peliculasDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public PeliculaDTO ConsultarPeliculaPorId(string idPelicula)
    {
        try
        {
            PeliculaServices peliculaServices = new PeliculaServices();
            Pelicula pelicula = peliculaServices.ObtenerPorId(idPelicula);
            PeliculaDTO dto = new PeliculaDTO(pelicula);
            return dto;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarPelicula(string genero_id, string usuario_id, string titulo, string anio, string resumen, string origen, string duracion, string clasificacion, string imagen, string directores, string actores)
    {
        try
        {
            //throw new Exception("Probando");
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                PeliculaServices peliculaServices = new PeliculaServices();
                resultado = peliculaServices.InsertarPelicula(genero_id, usuario_id, titulo, anio, resumen, origen, duracion, clasificacion, imagen, directores, actores);
            }
            else
            {
                resultado = "No log";
            }
            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string ActualizarPelicula(string pelicula_id, string genero_id, string usuario_id, string titulo, string anio, string resumen, string origen, string duracion, string clasificacion, string imagen, string directores, string actores)
    {
        try
        {
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                if (comprobarPropietario(usuario_id))
                {
                    PeliculaServices peliculaServices = new PeliculaServices();
                    resultado = peliculaServices.ActualizarPelicula(pelicula_id, genero_id, usuario_id, titulo, anio, resumen, origen, duracion, clasificacion, imagen, directores, actores);
                }
                else
                    resultado = "No propietario";
            }
            else
            {
                resultado = "No log";
            }
            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string EliminarPeliculaPorId(string Pelicula_id, string usuario_id)
    {
        try
        {
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                if (comprobarPropietario(usuario_id))
                {
                    PeliculaServices peliculaServices = new PeliculaServices();
                    resultado = peliculaServices.EliminarPelicula(Pelicula_id);
                }
                else
                    resultado = "No propietario";
            }
            else
            {
                resultado = "No log";
            }
            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<GeneroPeliculaDTO> ConsultarGenerosPelicula()
    {
        try
        {
            List<GeneroPeliculaDTO> generosPeliculaDTO = new List<GeneroPeliculaDTO>();
            PeliculaServices peliculaServices = new PeliculaServices();
            List<GeneroPelicula> generosPelicula = peliculaServices.ObtenerGeneros();

            foreach (GeneroPelicula genero in generosPelicula)
            {
                GeneroPeliculaDTO dto = new GeneroPeliculaDTO(genero);
                generosPeliculaDTO.Add(dto);
            }
            return generosPeliculaDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ClasificacionPeliculaDTO> ConsultarClasificacionesPelicula()
    {
        try
        {
            List<ClasificacionPeliculaDTO> clasificacionesPeliculaDTO = new List<ClasificacionPeliculaDTO>();
            PeliculaServices peliculaServices = new PeliculaServices();
            List<ClasificacionPelicula> clasificacionesPelicula = peliculaServices.ObtenerClasificaciones();

            foreach (ClasificacionPelicula clasificacion in clasificacionesPelicula)
            {
                ClasificacionPeliculaDTO dto = new ClasificacionPeliculaDTO(clasificacion);
                clasificacionesPeliculaDTO.Add(dto);
            }
            return clasificacionesPeliculaDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    #endregion

    #region Libros

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarComentarioLibro(string Libro_id, string usuario_id, string comentario, string puntaje)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                string usuario = ((Usuario)HttpContext.Current.Session["usuarioID"]).Id.ToString();
                ComentarioLibroServices comentarioLibroServices = new ComentarioLibroServices();
                resultado = comentarioLibroServices.InsertarComentarioLibro(Libro_id, usuario, comentario, puntaje);
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ComentarioLibroDTO> ConsultarUltimosComentariosLibro(string idLibro)
    {
        try
        {
            int id = Convert.ToInt32(idLibro);
            List<ComentarioLibroDTO> comentarioLibroDTO = new List<ComentarioLibroDTO>();
            ComentarioLibroServices comentarioLibroServices = new ComentarioLibroServices();
            List<ComentarioLibro> comentarioLibro = comentarioLibroServices.ObtenerUltimosComentarios(id);

            foreach (ComentarioLibro comLibro in comentarioLibro)
            {
                ComentarioLibroDTO dto = new ComentarioLibroDTO(comLibro);
                comentarioLibroDTO.Add(dto);
            }
            return comentarioLibroDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }


    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<LibroDTO> ConsultarTopTenLibros()
    {
        try
        {
            List<LibroDTO> librosDTO = new List<LibroDTO>();
            LibroServices libroServices = new LibroServices();
            List<Libro> libros = libroServices.ObtenerTopTen();

            foreach (Libro libro in libros)
            {
                LibroDTO dto = new LibroDTO(libro);
                librosDTO.Add(dto);
            }

            return librosDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public LibroDTO ConsultarLibroPorId(string idLibro)
    {
        try
        {
            LibroServices libroServices = new LibroServices();
            Libro libro = libroServices.ObtenerPorId(idLibro);
            LibroDTO dto = new LibroDTO(libro);

            return dto;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<GeneroLibroDTO> ConsultarGenerosLibro()
    {
        try
        {
            List<GeneroLibroDTO> generosLibroDTO = new List<GeneroLibroDTO>();
            LibroServices libroServices = new LibroServices();
            List<GeneroLibro> generosLibro = libroServices.ObtenerGeneros();

            foreach (GeneroLibro genero in generosLibro)
            {
                GeneroLibroDTO dto = new GeneroLibroDTO(genero);
                generosLibroDTO.Add(dto);
            }
            return generosLibroDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarLibro(string genero_id, string usuario_id, string titulo, string autores, string anio, string resumen, string idioma, string imagen, string isbn)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                LibroServices libroServices = new LibroServices();
                resultado = libroServices.InsertarLibro(genero_id, usuario_id, titulo, autores, anio, resumen, idioma, imagen, isbn);
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string ActualizarLibro(string libro_id, string genero_id, string usuario_id, string titulo, string autores, string anio, string resumen, string idioma, string imagen, string isbn)
    {
        try
        {
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                if (comprobarPropietario(usuario_id))
                {
                    LibroServices libroServices = new LibroServices();
                    resultado = libroServices.ActualizarLibro(libro_id, genero_id, usuario_id, titulo, autores, anio, resumen, idioma, imagen, isbn);
                }
                else
                    resultado = "No propietario";
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string EliminarLibroPorId(string Libro_id, string usuario_id)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                if (comprobarPropietario(usuario_id))
                {
                    LibroServices libroServices = new LibroServices();
                    resultado = libroServices.EliminarLibro(Libro_id);
                }
                else
                    resultado = "No propietario";
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }


    #endregion

    #region Restaurants

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarComentarioRestaurant(string Restaurant_id, string usuario_id, string comentario, string puntaje)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                string usuario = ((Usuario)HttpContext.Current.Session["usuarioID"]).Id.ToString();
                ComentarioRestaurantServices comentarioRestaurantServices = new ComentarioRestaurantServices();
                resultado = comentarioRestaurantServices.InsertarComentarioRestaurant(Restaurant_id, usuario, comentario, puntaje);
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ComentarioRestaurantDTO> ConsultarUltimosComentariosRestaurant(string idRestaurant)
    {
        try
        {
            int id = Convert.ToInt32(idRestaurant);
            List<ComentarioRestaurantDTO> comentarioRestaurantDTO = new List<ComentarioRestaurantDTO>();
            ComentarioRestaurantServices comentarioRestaurantServices = new ComentarioRestaurantServices();
            List<ComentarioRestaurant> comentarioRestaurant = comentarioRestaurantServices.ObtenerUltimosComentarios(id);

            foreach (ComentarioRestaurant comRest in comentarioRestaurant)
            {
                ComentarioRestaurantDTO dto = new ComentarioRestaurantDTO(comRest);
                comentarioRestaurantDTO.Add(dto);
            }
            return comentarioRestaurantDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<RestaurantDTO> ConsultarTopTenRestaurants()
    {
        try
        {
            List<RestaurantDTO> restaurantsDTO = new List<RestaurantDTO>();
            RestaurantServices restaurantServices = new RestaurantServices();
            List<Restaurant> restaurants = restaurantServices.ObtenerTopTen();

            foreach (Restaurant restaurant in restaurants)
            {
                RestaurantDTO dto = new RestaurantDTO(restaurant);
                restaurantsDTO.Add(dto);
            }
            return restaurantsDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public RestaurantDTO ConsultarRestaurantPorId(string idRestaurant)
    {
        try
        {
            RestaurantServices restaurantServices = new RestaurantServices();
            Restaurant restaurant = restaurantServices.ObtenerPorId(idRestaurant);
            RestaurantDTO dto = new RestaurantDTO(restaurant);

            return dto;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarRestaurant(string categoria_id, string usuario_id, string localidad_id, string provincia_id, string nombre, string direccion, string telefono, string horario, string imagen, string resumen)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                RestaurantServices restaurantServices = new RestaurantServices();
                resultado = restaurantServices.InsertarRestaurant(categoria_id, usuario_id, localidad_id, provincia_id, nombre, direccion, telefono, horario, imagen, resumen);
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string ActualizarRestaurant(string restaurant_id, string categoria_id, string usuario_id, string localidad_id, string provincia_id, string nombre, string direccion, string telefono, string horario, string imagen, string resumen)
    {
        string resultado;
        if (HttpContext.Current.Session["usuarioID"] != null)
        {
            if (comprobarPropietario(usuario_id))
            {
                RestaurantServices restaurantServices = new RestaurantServices();
                resultado = restaurantServices.ActualizarRestaurant(restaurant_id, categoria_id, usuario_id, localidad_id, provincia_id, nombre, direccion, telefono, horario, imagen, resumen);
            }
            else
                resultado = "No propietario";
        }
        else
        {
            resultado = "No log";
        }

        return resultado;
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string EliminarRestaurantPorId(string Restaurant_id, string usuario_id)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                if (comprobarPropietario(usuario_id))
                {
                    RestaurantServices restaurantServices = new RestaurantServices();
                    resultado = restaurantServices.EliminarRestaurant(Restaurant_id);
                }
                else
                    resultado = "No propietario";
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<CategoriaRestaurantDTO> ConsultarGenerosRestaurant()
    {
        try
        {
            List<CategoriaRestaurantDTO> categoriasRestaurantDTO = new List<CategoriaRestaurantDTO>();
            RestaurantServices restaurantServices = new RestaurantServices();
            List<CategoriaRestaurant> categoriasRestaurant = restaurantServices.ObtenerCategorias();

            foreach (CategoriaRestaurant categoria in categoriasRestaurant)
            {
                CategoriaRestaurantDTO dto = new CategoriaRestaurantDTO(categoria);
                categoriasRestaurantDTO.Add(dto);
            }
            return categoriasRestaurantDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    #endregion

    #region Obras de Teatro

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarComentarioTeatro(string Teatro_id, string usuario_id, string comentario, string puntaje)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                string usuario = ((Usuario)HttpContext.Current.Session["usuarioID"]).Id.ToString();
                ComentarioTeatroServices comentarioTeatroServices = new ComentarioTeatroServices();
                resultado = comentarioTeatroServices.InsertarComentarioTeatro(Teatro_id, usuario, comentario, puntaje);
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ComentarioTeatroDTO> ConsultarUltimosComentariosTeatro(string idTeatro)
    {
        try
        {
            int id = Convert.ToInt32(idTeatro);
            List<ComentarioTeatroDTO> comentarioTeatroDTO = new List<ComentarioTeatroDTO>();
            ComentarioTeatroServices comentarioTeatroServices = new ComentarioTeatroServices();
            List<ComentarioTeatro> comentarioTeatro = comentarioTeatroServices.ObtenerUltimosComentarios(id);

            foreach (ComentarioTeatro comTeatro in comentarioTeatro)
            {
                ComentarioTeatroDTO dto = new ComentarioTeatroDTO(comTeatro);
                comentarioTeatroDTO.Add(dto);
            }
            return comentarioTeatroDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ObraTeatroDTO> ConsultarTopTenTeatros()
    {
        try
        {
            List<ObraTeatroDTO> obraTeatroDTO = new List<ObraTeatroDTO>();
            ObraTeatroServices obraTeatroServices = new ObraTeatroServices();
            List<ObraTeatro> obrasTeatro = obraTeatroServices.ObtenerTopTen();

            foreach (ObraTeatro obra in obrasTeatro)
            {
                ObraTeatroDTO dto = new ObraTeatroDTO(obra);
                obraTeatroDTO.Add(dto);
            }
            return obraTeatroDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public ObraTeatroDTO ConsultarTeatroPorId(string idTeatro)
    {
        try
        {
            ObraTeatroServices obraTeatroServices = new ObraTeatroServices();
            ObraTeatro obraTeatro = obraTeatroServices.ObtenerPorId(idTeatro);
            ObraTeatroDTO dto = new ObraTeatroDTO(obraTeatro);

            return dto;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarObraTeatro(string genero_id, string usuario_id, string titulo, string teatro, string resumen, string imagen, string directores, string actores)
    {
        try
        {
            string resultado;

            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                ObraTeatroServices obraTeatroServices = new ObraTeatroServices();
                resultado = obraTeatroServices.InsertarObraTeatro(genero_id, usuario_id, titulo, teatro, resumen, imagen, directores, actores);
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string ActualizarObraTeatro(string teatro_id, string genero_id, string usuario_id, string titulo, string teatro, string resumen, string imagen, string directores, string actores)
    {
        try
        {
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                if (comprobarPropietario(usuario_id))
                {
                    ObraTeatroServices obraTeatroServices = new ObraTeatroServices();
                    resultado = obraTeatroServices.ActualizarObraTeatro(teatro_id, genero_id, usuario_id, titulo, teatro, resumen, imagen, directores, actores);
                }
                else
                    resultado = "No propietario";
            }
            else
            {
                resultado = "No log";
            }
            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string EliminarTeatroPorId(string Teatro_id, string usuario_id)
    {
        try
        {
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                if (comprobarPropietario(usuario_id))
                {
                    ObraTeatroServices obraTeatroServices = new ObraTeatroServices();
                    resultado = obraTeatroServices.EliminarObraTeatro(Teatro_id);
                }
                else
                    resultado = "No propietario";
            }
            else
            {
                resultado = "No log";
            }

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<GeneroTeatroDTO> ConsultarGenerosTeatro()
    {
        try
        {
            List<GeneroTeatroDTO> generosTeatroDTO = new List<GeneroTeatroDTO>();
            ObraTeatroServices obraTeatroServices = new ObraTeatroServices();
            List<GeneroTeatro> generosTeatro = obraTeatroServices.ObtenerGeneros();

            foreach (GeneroTeatro genero in generosTeatro)
            {
                GeneroTeatroDTO dto = new GeneroTeatroDTO(genero);
                generosTeatroDTO.Add(dto);
            }
            return generosTeatroDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    #endregion

    #region Usuarios

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public bool VerificarUsuario(string nombre, string password)
    {
        try
        {
            UsuarioServices usuarioServices = new UsuarioServices();
            Usuario usuario = usuarioServices.VerificarUsuario(nombre, password);
            if (usuario != null)
            {
                HttpContext.Current.Session["usuarioID"] = usuario;
                return true;
            }
            else
            {
                return false;
            }
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return false;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public Usuario ObtenerUsuario()
    {
        try
        {
            if (HttpContext.Current.Session["usuarioID"] != null)
                return (Usuario)HttpContext.Current.Session["usuarioID"];
            else
                return null;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public bool comprobarPropietario(string usuario)
    {
        try
        {
            if (HttpContext.Current.Session["usuarioID"] != null)
                return ((Usuario)HttpContext.Current.Session["usuarioID"]).Id == Convert.ToInt32(usuario);
            else
                return false;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return false;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string registrarUsuario(string usuario, string password, string email)
    {
        try
        {
            UsuarioServices usuarioServices = new UsuarioServices();
            return usuarioServices.RegistrarUsuario(usuario, password, email);
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string ActualizarUsuario(string nombre, string apellido, string fechaNacimiento, string sexo, string email)
    {
        try
        {
            string resultado;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                UsuarioServices usuarioServices = new UsuarioServices();
                resultado = usuarioServices.ActualizarUsuario(((Usuario)HttpContext.Current.Session["usuarioID"]).Id.ToString(), nombre, apellido, fechaNacimiento, sexo, email);
                //Actualizamos los datos del usuario en el Session//
                HttpContext.Current.Session["usuarioID"] = usuarioServices.ObtenerUsuario(((Usuario)HttpContext.Current.Session["usuarioID"]).Id);
            }
            else
                resultado = "No log";

            return resultado;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string BajaUsuario()
    {
        try
        {
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                UsuarioServices usuarioServices = new UsuarioServices();
                return usuarioServices.BajaUsuario(((Usuario)HttpContext.Current.Session["usuarioID"]).Id);
            }
            else
            {
                return "No log";
            }
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }


    #endregion

    #region Paises

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<PaisDTO> ConsultarPaises()
    {
        try
        {
            List<PaisDTO> paisesDTO = new List<PaisDTO>();
            PaisServices paisServices = new PaisServices();
            List<Pais> paises = paisServices.ObtenerPaises();

            foreach (Pais pais in paises)
            {
                PaisDTO dto = new PaisDTO(pais);
                paisesDTO.Add(dto);
            }
            return paisesDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    #endregion

    #region Provincias

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ProvinciaDTO> ConsultarProvincias()
    {
        try
        {
            List<ProvinciaDTO> provinciasDTO = new List<ProvinciaDTO>();
            ProvinciaServices provinciaServices = new ProvinciaServices();
            List<Provincia> provincias = provinciaServices.ObtenerProvincias();

            foreach (Provincia provincia in provincias)
            {
                ProvinciaDTO dto = new ProvinciaDTO(provincia);
                provinciasDTO.Add(dto);
            }
            return provinciasDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    #endregion

    #region Localidades

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<LocalidadDTO> ConsultarLocalidadesPorProvincia(int provinciaId)
    {
        try
        {
            List<LocalidadDTO> localidadesDTO = new List<LocalidadDTO>();
            LocalidadServices localidadServices = new LocalidadServices();
            List<Localidad> localidades = localidadServices.ObtenerLocalidadesPorProvincia(provinciaId);

            foreach (Localidad localidad in localidades)
            {
                LocalidadDTO dto = new LocalidadDTO(localidad);
                localidadesDTO.Add(dto);
            }
            return localidadesDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    #endregion

    #region Items

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ItemDTO> BusquedaItemAutocomplete(string titulo)
    {
        return BusquedaItemPorTitulo(titulo, 1, 12);
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ItemDTO> BusquedaItemPorTitulo(string titulo, int startRecord, int endRecord)
    {
        try
        {
            List<ItemDTO> itemsDTO = new List<ItemDTO>();
            ItemServices itemServices = new ItemServices();

            ParDatos resultado = itemServices.BusquedaPorNombre(titulo, startRecord, endRecord);
            List<Item> items = (List<Item>)resultado.DatoUno;

            foreach (Item item in items)
            {
                ItemDTO dto = new ItemDTO(item);
                itemsDTO.Add(dto);
            }
            return itemsDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }

    [WebMethod]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ItemDTO> BusquedaItemPorCategoria(string nombreItem, string categoria, string nombre, int puntajeDesde, int puntajeHasta, bool usuario, int startRecord, int endRecord)
    {
        List<ItemDTO> itemsDTO = new List<ItemDTO>();
        ItemServices itemServices = new ItemServices();
        int usuarioId = -1;

        if (HttpContext.Current.Session["usuarioID"] != null && usuario)
            usuarioId = ((Usuario)HttpContext.Current.Session["usuarioID"]).Id;

        ParDatos resultado = itemServices.BusquedaPorCategoria(nombreItem, categoria, nombre, puntajeDesde, puntajeHasta, usuarioId, startRecord, endRecord);
        List<Item> items = (List<Item>)resultado.DatoUno;

        foreach (Item item in items)
        {
            ItemDTO dto = new ItemDTO(item);
            itemsDTO.Add(dto);
        }
        return itemsDTO;
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public List<ComentarioItemDTO> ConsultarUltimaActividad()
    {
        try
        {
            List<ComentarioItemDTO> comentarioItemDTO = new List<ComentarioItemDTO>();
            ItemServices itemServices = new ItemServices();
            List<ComentarioItem> comentarioItem = null;
            if (HttpContext.Current.Session["usuarioID"] != null)
            {
                comentarioItem = itemServices.ConsultarUltimaActividad(((Usuario)HttpContext.Current.Session["usuarioID"]).Id);

                foreach (ComentarioItem comItem in comentarioItem)
                {
                    ComentarioItemDTO dto = new ComentarioItemDTO(comItem);
                    comentarioItemDTO.Add(dto);
                }
            }
            return comentarioItemDTO;
        }
        catch (Exception ex)
        {
            LogErrorServices logErrorService = new LogErrorServices();
            logErrorService.InsertarLogError(ex.GetType().ToString(), ex.StackTrace, ex.Message, ex.GetBaseException().ToString(), ex.Source);
            return null;
        }
    }


    #endregion

    #region Log

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public void cerrarSesion()
    {
        HttpContext.Current.Session["usuarioID"] = null;
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public bool comprobarSesion()
    {
        if (HttpContext.Current.Session["usuarioID"] != null)
            return true;
        else
            return false;
    }

    [WebMethod(EnableSession = true)]
    [System.Web.Script.Services.ScriptMethod(ResponseFormat = System.Web.Script.Services.ResponseFormat.Json)]
    public string InsertarLogError(string type, string stack, string message, string baseException, string source)
    {
        try
        {
            string resultado;
            LogErrorServices logErrorServices = new LogErrorServices();
            resultado = logErrorServices.InsertarLogError(type, stack, message, baseException, source);
            return resultado;
        }
        catch { return null; }
    }

    #endregion

}
